home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / lowlevel_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  9KB  |  314 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_LOWLEVEL_H
  4. #define _PPCPRAGMA_LOWLEVEL_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__LOWLEVEL_H
  7. #include <powerup/ppcinline/lowlevel.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef LOWLEVEL_BASE_NAME
  24. #define LOWLEVEL_BASE_NAME LowLevelBase
  25. #endif /* !LOWLEVEL_BASE_NAME */
  26.  
  27. #define    AddKBInt(intRoutine, intData)    _AddKBInt(LOWLEVEL_BASE_NAME, intRoutine, intData)
  28.  
  29. static __inline APTR
  30. _AddKBInt(void *LowLevelBase, APTR intRoutine, APTR intData)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) intRoutine;
  40.     MyCaos.a1        =(ULONG) intData;
  41.     MyCaos.caos_Un.Offset    =    (-60);
  42.     MyCaos.a6        =(ULONG) LowLevelBase;    
  43.     return((APTR)PPCCallOS(&MyCaos));
  44. }
  45.  
  46. #define    AddTimerInt(intRoutine, intData)    _AddTimerInt(LOWLEVEL_BASE_NAME, intRoutine, intData)
  47.  
  48. static __inline APTR
  49. _AddTimerInt(void *LowLevelBase, APTR intRoutine, APTR intData)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.a0        =(ULONG) intRoutine;
  59.     MyCaos.a1        =(ULONG) intData;
  60.     MyCaos.caos_Un.Offset    =    (-78);
  61.     MyCaos.a6        =(ULONG) LowLevelBase;    
  62.     return((APTR)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #define    AddVBlankInt(intRoutine, intData)    _AddVBlankInt(LOWLEVEL_BASE_NAME, intRoutine, intData)
  66.  
  67. static __inline APTR
  68. _AddVBlankInt(void *LowLevelBase, APTR intRoutine, APTR intData)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.a0        =(ULONG) intRoutine;
  78.     MyCaos.a1        =(ULONG) intData;
  79.     MyCaos.caos_Un.Offset    =    (-108);
  80.     MyCaos.a6        =(ULONG) LowLevelBase;    
  81.     return((APTR)PPCCallOS(&MyCaos));
  82. }
  83.  
  84. #define    ElapsedTime(context)    _ElapsedTime(LOWLEVEL_BASE_NAME, context)
  85.  
  86. static __inline ULONG
  87. _ElapsedTime(void *LowLevelBase, struct EClockVal *context)
  88. {
  89. struct Caos    MyCaos;
  90.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.M68kStart    =    NULL;
  92. //    MyCaos.M68kSize        =    0;
  93.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  94. //    MyCaos.PPCStart        =    NULL;
  95. //    MyCaos.PPCSize        =    0;
  96.     MyCaos.a0        =(ULONG) context;
  97.     MyCaos.caos_Un.Offset    =    (-102);
  98.     MyCaos.a6        =(ULONG) LowLevelBase;    
  99.     return((ULONG)PPCCallOS(&MyCaos));
  100. }
  101.  
  102. #define    GetKey()    _GetKey(LOWLEVEL_BASE_NAME)
  103.  
  104. static __inline ULONG
  105. _GetKey(void *LowLevelBase)
  106. {
  107. struct Caos    MyCaos;
  108.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  109. //    MyCaos.M68kStart    =    NULL;
  110. //    MyCaos.M68kSize        =    0;
  111.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  112. //    MyCaos.PPCStart        =    NULL;
  113. //    MyCaos.PPCSize        =    0;
  114.     MyCaos.caos_Un.Offset    =    (-48);
  115.     MyCaos.a6        =(ULONG) LowLevelBase;    
  116.     return((ULONG)PPCCallOS(&MyCaos));
  117. }
  118.  
  119. #define    GetLanguageSelection()    _GetLanguageSelection(LOWLEVEL_BASE_NAME)
  120.  
  121. static __inline UBYTE
  122. _GetLanguageSelection(void *LowLevelBase)
  123. {
  124. struct Caos    MyCaos;
  125.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  126. //    MyCaos.M68kStart    =    NULL;
  127. //    MyCaos.M68kSize        =    0;
  128.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  129. //    MyCaos.PPCStart        =    NULL;
  130. //    MyCaos.PPCSize        =    0;
  131.     MyCaos.caos_Un.Offset    =    (-36);
  132.     MyCaos.a6        =(ULONG) LowLevelBase;    
  133.     return((UBYTE)PPCCallOS(&MyCaos));
  134. }
  135.  
  136. #define    QueryKeys(queryArray, arraySize)    _QueryKeys(LOWLEVEL_BASE_NAME, queryArray, arraySize)
  137.  
  138. static __inline void
  139. _QueryKeys(void *LowLevelBase, struct KeyQuery *queryArray, unsigned long arraySize)
  140. {
  141. struct Caos    MyCaos;
  142.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  143. //    MyCaos.M68kStart    =    NULL;
  144. //    MyCaos.M68kSize        =    0;
  145.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  146. //    MyCaos.PPCStart        =    NULL;
  147. //    MyCaos.PPCSize        =    0;
  148.     MyCaos.a0        =(ULONG) queryArray;
  149.     MyCaos.d1        =(ULONG) arraySize;
  150.     MyCaos.caos_Un.Offset    =    (-54);
  151.     MyCaos.a6        =(ULONG) LowLevelBase;    
  152.     PPCCallOS(&MyCaos);
  153. }
  154.  
  155. #define    ReadJoyPort(port)    _ReadJoyPort(LOWLEVEL_BASE_NAME, port)
  156.  
  157. static __inline ULONG
  158. _ReadJoyPort(void *LowLevelBase, unsigned long port)
  159. {
  160. struct Caos    MyCaos;
  161.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  162. //    MyCaos.M68kStart    =    NULL;
  163. //    MyCaos.M68kSize        =    0;
  164.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  165. //    MyCaos.PPCStart        =    NULL;
  166. //    MyCaos.PPCSize        =    0;
  167.     MyCaos.d0        =(ULONG) port;
  168.     MyCaos.caos_Un.Offset    =    (-30);
  169.     MyCaos.a6        =(ULONG) LowLevelBase;    
  170.     return((ULONG)PPCCallOS(&MyCaos));
  171. }
  172.  
  173. #define    RemKBInt(intHandle)    _RemKBInt(LOWLEVEL_BASE_NAME, intHandle)
  174.  
  175. static __inline void
  176. _RemKBInt(void *LowLevelBase, APTR intHandle)
  177. {
  178. struct Caos    MyCaos;
  179.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  180. //    MyCaos.M68kStart    =    NULL;
  181. //    MyCaos.M68kSize        =    0;
  182.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  183. //    MyCaos.PPCStart        =    NULL;
  184. //    MyCaos.PPCSize        =    0;
  185.     MyCaos.a1        =(ULONG) intHandle;
  186.     MyCaos.caos_Un.Offset    =    (-66);
  187.     MyCaos.a6        =(ULONG) LowLevelBase;    
  188.     PPCCallOS(&MyCaos);
  189. }
  190.  
  191. #define    RemTimerInt(intHandle)    _RemTimerInt(LOWLEVEL_BASE_NAME, intHandle)
  192.  
  193. static __inline void
  194. _RemTimerInt(void *LowLevelBase, APTR intHandle)
  195. {
  196. struct Caos    MyCaos;
  197.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  198. //    MyCaos.M68kStart    =    NULL;
  199. //    MyCaos.M68kSize        =    0;
  200.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  201. //    MyCaos.PPCStart        =    NULL;
  202. //    MyCaos.PPCSize        =    0;
  203.     MyCaos.a1        =(ULONG) intHandle;
  204.     MyCaos.caos_Un.Offset    =    (-84);
  205.     MyCaos.a6        =(ULONG) LowLevelBase;    
  206.     PPCCallOS(&MyCaos);
  207. }
  208.  
  209. #define    RemVBlankInt(intHandle)    _RemVBlankInt(LOWLEVEL_BASE_NAME, intHandle)
  210.  
  211. static __inline void
  212. _RemVBlankInt(void *LowLevelBase, APTR intHandle)
  213. {
  214. struct Caos    MyCaos;
  215.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  216. //    MyCaos.M68kStart    =    NULL;
  217. //    MyCaos.M68kSize        =    0;
  218.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  219. //    MyCaos.PPCStart        =    NULL;
  220. //    MyCaos.PPCSize        =    0;
  221.     MyCaos.a1        =(ULONG) intHandle;
  222.     MyCaos.caos_Un.Offset    =    (-114);
  223.     MyCaos.a6        =(ULONG) LowLevelBase;    
  224.     PPCCallOS(&MyCaos);
  225. }
  226.  
  227. #define    SetJoyPortAttrsA(portNumber, tagList)    _SetJoyPortAttrsA(LOWLEVEL_BASE_NAME, portNumber, tagList)
  228.  
  229. static __inline BOOL
  230. _SetJoyPortAttrsA(void *LowLevelBase, unsigned long portNumber, struct TagItem *tagList)
  231. {
  232. struct Caos    MyCaos;
  233.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  234. //    MyCaos.M68kStart    =    NULL;
  235. //    MyCaos.M68kSize        =    0;
  236.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  237. //    MyCaos.PPCStart        =    NULL;
  238. //    MyCaos.PPCSize        =    0;
  239.     MyCaos.d0        =(ULONG) portNumber;
  240.     MyCaos.a1        =(ULONG) tagList;
  241.     MyCaos.caos_Un.Offset    =    (-132);
  242.     MyCaos.a6        =(ULONG) LowLevelBase;    
  243.     return((BOOL)PPCCallOS(&MyCaos));
  244. }
  245.  
  246. #ifndef NO_PPCINLINE_STDARG
  247. #define SetJoyPortAttrs(a0, tags...) \
  248.     ({ULONG _tags[] = { tags }; SetJoyPortAttrsA((a0), (struct TagItem *)_tags);})
  249. #endif /* !NO_PPCINLINE_STDARG */
  250.  
  251. #define    StartTimerInt(intHandle, timeInterval, continuous)    _StartTimerInt(LOWLEVEL_BASE_NAME, intHandle, timeInterval, continuous)
  252.  
  253. static __inline void
  254. _StartTimerInt(void *LowLevelBase, APTR intHandle, unsigned long timeInterval, long continuous)
  255. {
  256. struct Caos    MyCaos;
  257.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  258. //    MyCaos.M68kStart    =    NULL;
  259. //    MyCaos.M68kSize        =    0;
  260.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  261. //    MyCaos.PPCStart        =    NULL;
  262. //    MyCaos.PPCSize        =    0;
  263.     MyCaos.a1        =(ULONG) intHandle;
  264.     MyCaos.d0        =(ULONG) timeInterval;
  265.     MyCaos.d1        =(ULONG) continuous;
  266.     MyCaos.caos_Un.Offset    =    (-96);
  267.     MyCaos.a6        =(ULONG) LowLevelBase;    
  268.     PPCCallOS(&MyCaos);
  269. }
  270.  
  271. #define    StopTimerInt(intHandle)    _StopTimerInt(LOWLEVEL_BASE_NAME, intHandle)
  272.  
  273. static __inline void
  274. _StopTimerInt(void *LowLevelBase, APTR intHandle)
  275. {
  276. struct Caos    MyCaos;
  277.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  278. //    MyCaos.M68kStart    =    NULL;
  279. //    MyCaos.M68kSize        =    0;
  280.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  281. //    MyCaos.PPCStart        =    NULL;
  282. //    MyCaos.PPCSize        =    0;
  283.     MyCaos.a1        =(ULONG) intHandle;
  284.     MyCaos.caos_Un.Offset    =    (-90);
  285.     MyCaos.a6        =(ULONG) LowLevelBase;    
  286.     PPCCallOS(&MyCaos);
  287. }
  288.  
  289. #define    SystemControlA(tagList)    _SystemControlA(LOWLEVEL_BASE_NAME, tagList)
  290.  
  291. static __inline ULONG
  292. _SystemControlA(void *LowLevelBase, struct TagItem *tagList)
  293. {
  294. struct Caos    MyCaos;
  295.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  296. //    MyCaos.M68kStart    =    NULL;
  297. //    MyCaos.M68kSize        =    0;
  298.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  299. //    MyCaos.PPCStart        =    NULL;
  300. //    MyCaos.PPCSize        =    0;
  301.     MyCaos.a1        =(ULONG) tagList;
  302.     MyCaos.caos_Un.Offset    =    (-72);
  303.     MyCaos.a6        =(ULONG) LowLevelBase;    
  304.     return((ULONG)PPCCallOS(&MyCaos));
  305. }
  306.  
  307. #ifndef NO_PPCINLINE_STDARG
  308. #define SystemControl(tags...) \
  309.     ({ULONG _tags[] = { tags }; SystemControlA((struct TagItem *)_tags);})
  310. #endif /* !NO_PPCINLINE_STDARG */
  311.  
  312. #endif /* SASC Pragmas */
  313. #endif /* !_PPCPRAGMA_LOWLEVEL_H */
  314.